// 静态类型

const str: string = "1244t5";

const num: number = 124;

const myNull: null = null;
let myUndefined: undefined;

myUndefined = undefined;

let myUnKnown: unknown; // 待定 :现在不知道当前的类型是什么 先用unknown代替
let myAny: any; // 任意  不建议用any 因为失去了ts类型判断的意义 T extends XX ? any []

// 用了第三方包 : js语言

// myAny = '134'
// myUnKnown = 124
// myUnKnown = '124'
// myUnKnown = {}

let myNever: never; // ts出现的新东西都是类型
// myNever = null// never

//
function abc(): never {
  // 此方法出错了 没有返回值
  throw new Error();
  // return ''
}

function abc1(): void {
  // 此方法也没有返回值 或者返回一个undefined
}

// 数组类型
const arr1: string[] = ["12", "3", "4"];
// 元组 : 束缚数组的每一项
let arr2: [string, number] = ["12", 3];
arr2 = ["12344", 145];

// [string , number]

// 对象类型
// 函数类型
// 应用

// name :是ts的关键字 在声明变量尽量避开
// 引用类型的类型声明
type UserType = { title: string; id: number };
type UserTypeArr = Array<UserType>; //UserType[]; //
let obj1: UserType = { title: "123", id: 123 };
obj1 = { title: "123", id: 123 };

// [{title : 'zhangsan' , id : 1} , {title : 'zhangsan' , id : 2} ]

// 类型别名 type
const arrUser: UserTypeArr = [
  { id: 1, title: "123" },
  { id: 1, title: "123" },
  { id: 1, title: "123" },
];

// 方法类型 (args : number)=>number
type FnType = (args: string) => number;

// type FnType2 = (args: {
//   title: string;
//   sex: boolean;
// }) => [{ title: string; sex: boolean }, number];
// const getNumber: FnType2 = (args: { title: string; sex: boolean }) => {
//   return [args, 10];
// };

// 写一个方法 参数 要求是{title:string,sex:boolean}
// 返回值 [{title:string,sex:boolean},number]

// 写一个对象类型
// {
//   key : string,
//   fn : 参数是: [string, number]  返回值 string[]
//}

type ObjType = {
  key: string;
  fn: (args: [string, number]) => string[]; // [string, number]: 元组
};

const obj: ObjType = {
  key: "zhangsan",
  fn: (args: [string, number]) => {
    return ["1", "2", "3"];
  },
};


// 泛型 : 泛指  T U K P X Y Z Q W E R
// 最基本的结构 : 泛型结构  方法名字 高阶类型的后面<一般都写 T>
function getString<T>(args : T) : T{
  return args
} // : 函数参数 : T 返回值 : T

// 2. 在调用的时候才能确定泛型的类型
// const str2 = getString<string>('zhangsan')
const str2 = getString<number>(1)

// type 后面也可以加<>
// 泛型的好处 : 简化我们的代码 
// 高级类型的时候 可以进行高级类型的推断 
type FnType2<T> = (args: T) => [T, number];

const getNumber: FnType2<{
  title: string;
  sex: boolean;
}> = (args: { title: string; sex: boolean }) => {
  return [args, 10];
};